package com.rbac.admin.util;

import com.rbac.admin.dto.MenuDTO;
import com.rbac.admin.entity.system.SystemMenu;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 菜单转换工具类
 *
 * @author rbac-admin
 * @since 2024-07-20
 */
public class MenuConverter {

    /**
     * 将SystemMenu转换为MenuDTO
     *
     * @param menu 菜单实体
     * @return 菜单DTO
     */
    public static MenuDTO convertToDTO(SystemMenu menu) {
        if (menu == null) {
            return null;
        }

        // 打印实体类对象，用于调试
        System.out.println("转换前的SystemMenu对象: " + menu);

        MenuDTO dto = new MenuDTO();
        dto.setId(String.valueOf(menu.getId()));
        dto.setParentId(menu.getParentId());
        // 从menu_name映射到name
        dto.setName(menu.getName());
        
        // 转换菜单类型
        if (menu.getType() != null) {
            switch (menu.getType()) {
                case "1":
                    dto.setType("catalog");
                    break;
                case "2":
                    dto.setType("menu");
                    break;
                case "3":
                    dto.setType("button");
                    break;
                default:
                    dto.setType("menu"); // 默认值
            }
        }
        
        dto.setPath(menu.getPath());
        dto.setComponent(menu.getComponent());
        dto.setPermission(menu.getPermission());
        dto.setIcon(menu.getIcon());
        dto.setSort(menu.getSort());
        dto.setVisible(menu.getVisible());
        dto.setStatus(menu.getStatus());
        dto.setCreateBy(menu.getCreateBy());
        dto.setCreateTime(menu.getCreateTime());
        dto.setUpdateBy(menu.getUpdateBy());
        dto.setUpdateTime(menu.getUpdateTime());
        
        // 打印转换后的DTO对象，用于调试
        System.out.println("转换后的MenuDTO对象: " + dto);
        
        // 递归转换子菜单
        if (menu.getChildren() != null && !menu.getChildren().isEmpty()) {
            dto.setChildren(convertToDTOList(menu.getChildren()));
        }
        
        return dto;
    }

    /**
     * 将SystemMenu列表转换为MenuDTO列表
     *
     * @param menuList 菜单实体列表
     * @return 菜单DTO列表
     */
    public static List<MenuDTO> convertToDTOList(List<SystemMenu> menuList) {
        if (menuList == null || menuList.isEmpty()) {
            return new ArrayList<>();
        }
        
        return menuList.stream()
                .map(MenuConverter::convertToDTO)
                .collect(Collectors.toList());
    }

    /**
     * 构建MenuDTO树结构
     *
     * @param dtoList 菜单DTO列表
     * @return 树形结构的菜单DTO列表
     */
    public static List<MenuDTO> buildTree(List<MenuDTO> dtoList) {
        if (dtoList == null || dtoList.isEmpty()) {
            return new ArrayList<>();
        }
        
        // 按sort字段对整个列表进行预排序
        List<MenuDTO> sortedList = new ArrayList<>(dtoList);
        sortedList.sort((a, b) -> {
            Integer sortA = a.getSort() != null ? a.getSort() : 0;
            Integer sortB = b.getSort() != null ? b.getSort() : 0;
            return sortA.compareTo(sortB);
        });
        
        // 按ID分组
        Map<String, MenuDTO> dtoMap = new HashMap<>();
        for (MenuDTO dto : sortedList) {
            dtoMap.put(String.valueOf(dto.getId()), dto);
        }
        
        // 构建树结构
        List<MenuDTO> rootList = new ArrayList<>();
        for (MenuDTO dto : sortedList) {
            // 如果是根节点，直接添加到结果列表
            if (dto.getParentId() == null || "0".equals(dto.getParentId())) {
                rootList.add(dto);
            } else {
                // 子节点，添加到父节点的children集合
                MenuDTO parent = dtoMap.get(dto.getParentId());
                if (parent != null) {
                    if (parent.getChildren() == null) {
                        parent.setChildren(new ArrayList<>());
                    }
                    parent.getChildren().add(dto);
                }
            }
        }
        
        // 对每个父节点的子节点列表进行排序
        for (MenuDTO dto : dtoMap.values()) {
            if (dto.getChildren() != null && !dto.getChildren().isEmpty()) {
                dto.getChildren().sort((a, b) -> {
                    Integer sortA = a.getSort() != null ? a.getSort() : 0;
                    Integer sortB = b.getSort() != null ? b.getSort() : 0;
                    return sortA.compareTo(sortB);
                });
            }
        }
        
        return rootList;
    }
} 
